/**
 * 导航模块 - 专注于页面导航和UI交互
 */

// 调试开关
const NAV_DEBUG = true;

// 调试日志
function logDebug(...args) {
    if (NAV_DEBUG) {
        console.log('[Navigation]', ...args);
    }
}

// 修复：延迟执行，确保DOM已加载
setTimeout(async function() {
    logDebug('延迟执行导航初始化');
    if (document.getElementById('pages-tree')) {
        try {
            // 等待数据服务初始化完成
            await DataService.initData();
            
            // 初始化导航界面
            initNavigation();
        } catch (error) {
            console.error('导航初始化失败:', error);
            
            // 检查是否有可用数据
            if (DataService.getPagesData().pages && DataService.getPagesData().pages.length > 0) {
                logDebug('使用备用数据初始化导航');
                initNavigation();
            } else {
                showErrorMessage('无法加载页面数据，请刷新页面重试');
            }
        }
    } else {
        console.error('DOM元素未加载，请手动初始化');
    }
}, 500);

/**
 * 显示错误消息
 */
function showErrorMessage(message) {
    const container = document.getElementById('pages-tree');
    if (container) {
        container.innerHTML = `
            <div style="padding: 20px; color: #ff4d4f; text-align: center;">
                <p>${message}</p>
                <button onclick="location.reload()" style="padding: 5px 10px; margin-top: 10px;">
                    刷新页面
                </button>
            </div>
        `;
    }
}

/**
 * 初始化导航
 */
function initNavigation() {
    logDebug('开始初始化导航');
    
    // 渲染页面树
    renderPageTree();
    
    // 添加点击事件
    attachPageClickEvents();
    
    // 初始化添加根页面按钮
    initAddRootPage();
    
    // 初始化搜索功能
    initSearchFunction();
    
    // 加载活动页面
    loadActivePage();
    
    // 设置右键菜单功能
    document.addEventListener('click', () => {
        // 点击页面任意位置关闭上下文菜单
        closeContextMenu();
    });
    
    logDebug('导航初始化完成');
}

/**
 * 渲染页面树
 */
function renderPageTree() {
    // 获取最新的页面数据
    const pagesData = DataService.getPagesData();
    
    const pagesTree = document.getElementById('pages-tree');
    if (!pagesTree) return;
    
    logDebug('渲染页面树，页面数量:', pagesData.pages.length);
    
    pagesTree.innerHTML = '';
    
    if (!pagesData.pages || pagesData.pages.length === 0) {
        logDebug('页面数据为空，显示空状态');
        pagesTree.innerHTML = `
            <div style="padding: 20px; color: #999; text-align: center;">
                <p>暂无页面</p>
                <p>点击右上角"+"创建新页面</p>
            </div>
        `;
        return;
    }
    
    // 递归创建页面元素
    pagesData.pages.forEach(page => {
        const pageElement = createPageElement(page);
        pagesTree.appendChild(pageElement);
    });
}

/**
 * 创建页面元素
 */
function createPageElement(page) {
    const li = document.createElement('li');
    li.className = 'page-item';
    li.setAttribute('data-id', page.id);
    
    const pageRow = document.createElement('div');
    pageRow.className = 'page-row';
    pageRow.setAttribute('data-id', page.id);
    pageRow.setAttribute('data-type', page.type);
    
    // 如果是当前激活页面，添加active类
    if (page.id === DataService.getActivePageId()) {
        pageRow.classList.add('active');
    }
    
    // 添加折叠/展开按钮（仅目录类型）
    const toggleBtn = document.createElement('div');
    toggleBtn.className = 'toggle-btn';
    if (page.type === 'directory') {
        toggleBtn.innerHTML = '▶';
        if (page.expanded) {
            toggleBtn.classList.add('expanded');
        }
    }
    pageRow.appendChild(toggleBtn);
    
    // 添加图标
    const icon = document.createElement('div');
    icon.className = 'page-icon';
    icon.innerHTML = page.type === 'directory' ? '📁' : '📄';
    pageRow.appendChild(icon);
    
    // 添加标题
    const title = document.createElement('div');
    title.className = 'page-title';
    title.textContent = page.title;
    pageRow.appendChild(title);
    
    // 添加右键菜单事件
    pageRow.addEventListener('contextmenu', (e) => {
        e.preventDefault();
        showContextMenu(e, page);
    });
    
    // 添加点击事件
    pageRow.addEventListener('click', () => {
        // 通过事件代理处理
        handlePageClick(page.id);
    });
    
    li.appendChild(pageRow);
    
    // 如果是目录且有子项，创建子项容器
    if (page.type === 'directory' && page.children && page.children.length > 0) {
        const subpages = document.createElement('ul');
        subpages.className = 'subpages';
        if (page.expanded) {
            subpages.classList.add('expanded');
        }
        
        page.children.forEach(childPage => {
            const childElement = createPageElement(childPage);
            subpages.appendChild(childElement);
        });
        
        li.appendChild(subpages);
    }
    
    return li;
}

/**
 * 切换目录展开/折叠状态
 */
function toggleDirectory(page) {
    if (page.type !== 'directory') return;
    
    // 切换展开状态
    page.expanded = !page.expanded;
    
    // 保存状态
    DataService.savePagesData();
    
    // 重新渲染页面树
    renderPageTree();
}

/**
 * 选择页面
 */
async function selectPage(page) {
    if (!page) return;
    
    // 清除之前激活状态
    const activeRows = document.querySelectorAll('.page-row.active');
    activeRows.forEach(row => row.classList.remove('active'));
    
    // 如果是目录，切换展开状态
    if (page.type === 'directory') {
        toggleDirectory(page);
        return;
    }
    
    // 设置新的活动页面ID
    DataService.setActivePageId(page.id);
    
    // 激活当前选中项
    const pageRow = document.querySelector(`.page-row[data-id="${page.id}"]`);
    if (pageRow) {
        pageRow.classList.add('active');
    }
    
    // 加载页面内容
    await loadPageContent(page.id);
    
    // 更新浏览器标题
    document.title = `${page.title} - Notion-like编辑器`;
}

/**
 * 加载页面内容
 */
async function loadPageContent(pageId) {
    try {
        logDebug(`加载页面内容: ${pageId}`);
        
        // 获取页面对象
        const page = DataService.findPageById(pageId);
        if (!page) {
            throw new Error(`找不到页面: ${pageId}`);
        }
        
        // 尝试从文件系统加载内容
        let content = await DataService.loadPageContentFromFile(pageId);
        
        // 如果文件内容为空，从localStorage获取
        if (!content) {
            const pageContents = DataService.getPageContents();
            content = pageContents[pageId] || '';
            logDebug(`从localStorage获取页面内容，长度: ${content.length}`);
        }
        
        // 获取编辑器元素
        const editor = document.getElementById('editor');
        if (editor) {
            // 清空编辑器
            editor.innerHTML = content || '';
            
            if (!content) {
                logDebug('页面内容为空，创建默认结构');
                // 如果没有内容，创建默认结构
                const titleBlock = document.createElement('div');
                titleBlock.className = 'title-block';
                titleBlock.contentEditable = true;
                titleBlock.textContent = page.title;
                
                titleBlock.addEventListener('input', () => {
                    const page = DataService.findPageById(pageId);
                    if (page) {
                        page.title = titleBlock.textContent;
                        const pageTitle = document.querySelector(`.page-item[data-id="${pageId}"] .page-title`);
                        if (pageTitle) {
                            pageTitle.textContent = titleBlock.textContent;
                        }
                        DataService.savePagesData();
                        document.title = `${titleBlock.textContent} - Notion-like编辑器`;
                    }
                    savePageContent();
                });
                
                editor.appendChild(titleBlock);
                const block = createBlock();
                editor.appendChild(block);
                savePageContent();
            }
            
            // 重新初始化编辑器功能
            if (typeof initBlockHandling === 'function') initBlockHandling();
            if (typeof setupPasteHandler === 'function') setupPasteHandler();
            if (typeof setupDragAndDrop === 'function') setupDragAndDrop();
            if (typeof setupAIPrompt === 'function') setupAIPrompt();
            
            // 更新页面标题
            document.title = `${page.title} - Notion-like编辑器`;
            
            logDebug('页面内容加载完成');
        }
    } catch (error) {
        console.error('加载页面失败:', error);
    }
}

/**
 * 保存页面内容
 */
function savePageContent() {
    DataService.savePageContent();
}

/**
 * 显示右键菜单
 */
function showContextMenu(event, page) {
    // 关闭已有的上下文菜单
    closeContextMenu();
    
    // 创建上下文菜单
    const menu = document.createElement('div');
    menu.className = 'context-menu';
    menu.style.left = `${event.pageX}px`;
    menu.style.top = `${event.pageY}px`;
    
    // 创建菜单项
    const menuItems = [];
    
    if (page.type === 'directory') {
        // 目录操作
        menuItems.push({
            text: '新建页面',
            action: () => {
                // 在当前目录下创建新页面
                const newPage = DataService.createNewPage(page.id, 'page');
                renderPageTree();
                setTimeout(() => {
                    // 找到新创建的页面元素
                    const pageItem = document.querySelector(`.page-item[data-id="${newPage.id}"]`);
                    if (pageItem) {
                        const titleElem = pageItem.querySelector('.page-title');
                        startEditing(titleElem, newPage);
                    }
                }, 100);
            }
        });
        
        menuItems.push({
            text: '新建文件夹',
            action: () => {
                // 在当前目录下创建新文件夹
                const newFolder = DataService.createNewPage(page.id, 'directory');
                renderPageTree();
                setTimeout(() => {
                    // 找到新创建的文件夹元素
                    const folderItem = document.querySelector(`.page-item[data-id="${newFolder.id}"]`);
                    if (folderItem) {
                        const titleElem = folderItem.querySelector('.page-title');
                        startEditing(titleElem, newFolder);
                    }
                }, 100);
            }
        });
    }
    
    // 通用操作
    menuItems.push({
        text: '重命名',
        action: () => {
            const pageItem = document.querySelector(`.page-item[data-id="${page.id}"]`);
            if (pageItem) {
                const titleElem = pageItem.querySelector('.page-title');
                startEditing(titleElem, page);
            }
        }
    });
    
    menuItems.push({
        text: '复制',
        action: () => {
            duplicatePage(page);
        }
    });
    
    menuItems.push({
        text: '删除',
        action: () => {
            if (confirm(`确定要删除 "${page.title}" 吗？`)) {
                DataService.deletePage(page.id);
                renderPageTree();
                
                // 如果删除的是当前页面，加载第一个页面
                const pagesData = DataService.getPagesData();
                if (DataService.getActivePageId() === null && pagesData.pages.length > 0) {
                    // 查找第一个非目录的页面
                    const findFirstPage = (pages) => {
                        for (const p of pages) {
                            if (p.type === 'page') {
                                return p;
                            } else if (p.children && p.children.length > 0) {
                                const found = findFirstPage(p.children);
                                if (found) return found;
                            }
                        }
                        return null;
                    };
                    
                    const firstPage = findFirstPage(pagesData.pages);
                    if (firstPage) {
                        selectPage(firstPage);
                    }
                }
            }
        }
    });
    
    // 添加菜单项到菜单
    menuItems.forEach(item => {
        const menuItem = document.createElement('div');
        menuItem.className = 'menu-item';
        menuItem.textContent = item.text;
        menuItem.addEventListener('click', () => {
            item.action();
            closeContextMenu();
        });
        menu.appendChild(menuItem);
    });
    
    // 添加菜单到页面
    document.body.appendChild(menu);
    
    // 阻止默认右键菜单
    event.preventDefault();
}

/**
 * 关闭右键菜单
 */
function closeContextMenu() {
    const menu = document.querySelector('.context-menu');
    if (menu) {
        menu.remove();
    }
}

/**
 * 开始编辑标题
 */
function startEditing(titleElement, page) {
    if (!titleElement || titleElement.classList.contains('editing')) return;
    
    // 标记为编辑状态
    titleElement.classList.add('editing');
    titleElement.setAttribute('contenteditable', 'true');
    titleElement.focus();
    
    // 选中所有文本
    document.execCommand('selectAll', false, null);
    
    // 结束编辑的函数
    const finishEditing = () => {
        titleElement.classList.remove('editing');
        titleElement.removeAttribute('contenteditable');
        
        // 更新页面标题
        if (page) {
            const newTitle = titleElement.textContent.trim() || '无标题';
            page.title = newTitle;
            
            // 如果是当前活动页面，更新浏览器标题
            if (page.id === DataService.getActivePageId()) {
                document.title = `${newTitle} - Notion-like编辑器`;
            }
            
            // 保存数据
            DataService.savePagesData();
        }
    };
    
    // 失去焦点时完成编辑
    titleElement.addEventListener('blur', finishEditing, { once: true });
    
    // 按下回车键时完成编辑
    titleElement.addEventListener('keydown', function(e) {
        if (e.key === 'Enter') {
            e.preventDefault();
            finishEditing();
        }
    });
}

/**
 * 处理页面点击事件
 */
function handlePageClick(pageId) {
    const page = DataService.findPageById(pageId);
    if (page) {
        selectPage(page);
    }
}

/**
 * 加载活动页面
 */
function loadActivePage() {
    // 获取活动页面ID
    const activeId = DataService.getActivePageId();
    const pagesData = DataService.getPagesData();
    
    if (activeId) {
        // 查找页面
        const findPage = (pages, id) => {
            for (let i = 0; i < pages.length; i++) {
                if (pages[i].id === id) {
                    return pages[i];
                }
                if (pages[i].children) {
                    const found = findPage(pages[i].children, id);
                    if (found) {
                        return found;
                    }
                }
            }
            return null;
        };
        
        // 查找并选择页面
        const page = findPage(pagesData.pages, activeId);
        if (page) {
            selectPage(page);
            
            // 确保父目录处于展开状态
            const ensureParentsExpanded = (pages, targetId) => {
                // 查找包含目标页面的父目录
                for (let i = 0; i < pages.length; i++) {
                    const page = pages[i];
                    
                    // 如果是目录且有子页面
                    if (page.type === 'directory' && page.children) {
                        // 检查子页面中是否包含目标页面
                        const hasTarget = page.children.some(child => 
                            child.id === targetId || 
                            (child.type === 'directory' && ensureParentsExpanded(child.children || [], targetId))
                        );
                        
                        // 如果包含目标页面，确保该目录处于展开状态
                        if (hasTarget) {
                            page.expanded = true;
                            return true;
                        }
                    }
                }
                return false;
            };
            
            // 确保父目录展开
            ensureParentsExpanded(pagesData.pages, activeId);
            
            // 重新渲染页面树
            renderPageTree();
            
            return;
        }
    }
    
    // 如果没有活动页面或找不到活动页面，加载第一个页面
    if (pagesData.pages.length > 0) {
        // 查找第一个非目录的页面
        const findFirstPage = (pages) => {
            for (const p of pages) {
                if (p.type === 'page') {
                    return p;
                } else if (p.children && p.children.length > 0) {
                    const found = findFirstPage(p.children);
                    if (found) return found;
                }
            }
            return null;
        };
        
        const firstPage = findFirstPage(pagesData.pages);
        if (firstPage) {
            selectPage(firstPage);
        } else {
            // 如果没有非目录页面，选择第一个页面（无论类型）
            selectPage(pagesData.pages[0]);
        }
    }
}

/**
 * 设置活动页面
 */
function setActivePage(pageId) {
    DataService.setActivePageId(pageId);
    
    // 清除所有活动状态
    const activeRows = document.querySelectorAll('.page-row.active');
    activeRows.forEach(row => row.classList.remove('active'));
    
    // 设置新的活动状态
    const pageRow = document.querySelector(`.page-row[data-id="${pageId}"]`);
    if (pageRow) {
        pageRow.classList.add('active');
    }
}

/**
 * 初始化添加根页面按钮
 */
function initAddRootPage() {
    const addButton = document.getElementById('add-root-page');
    if (addButton) {
        addButton.addEventListener('click', () => {
            // 创建新页面
            const newPage = DataService.createNewPage(null, 'page');
            
            // 重新渲染页面树
            renderPageTree();
            
            // 选择新页面
            selectPage(newPage);
            
            // 开始编辑新页面标题
            setTimeout(() => {
                const pageItem = document.querySelector(`.page-item[data-id="${newPage.id}"]`);
                if (pageItem) {
                    const titleElem = pageItem.querySelector('.page-title');
                    startEditing(titleElem, newPage);
                }
            }, 100);
        });
    }
}

/**
 * 复制页面
 */
function duplicatePage(page) {
    if (!page) return;
    
    // 复制页面对象
    const newPage = {
        ...page,
        id: `page_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
        title: `${page.title} (复制)`
    };
    
    // 如果是目录，递归复制子页面
    if (page.type === 'directory' && page.children) {
        newPage.children = JSON.parse(JSON.stringify(page.children));
    }
    
    const pagesData = DataService.getPagesData();
    
    // 查找父级页面并添加
    const findParentAndAdd = (pages, id) => {
        // 检查当前层级是否包含目标页面
        const isDirectChild = pages.some(p => p.id === id);
        if (isDirectChild) {
            // 如果是直接子页面，添加到当前层级
            pages.push(newPage);
            return true;
        }
        
        // 递归查找子目录
        for (let i = 0; i < pages.length; i++) {
            if (pages[i].type === 'directory' && pages[i].children) {
                if (findParentAndAdd(pages[i].children, id)) {
                    return true;
                }
            }
        }
        
        return false;
    };
    
    // 尝试找到父页面并添加
    if (!findParentAndAdd(pagesData.pages, page.id)) {
        // 如果找不到父页面，添加到根目录
        pagesData.pages.push(newPage);
    }
    
    // 保存数据
    DataService.savePagesData();
    
    // 重新渲染页面树
    renderPageTree();
    
    // 如果复制的是内容页面，复制内容
    if (page.type === 'page') {
        const pageContents = DataService.getPageContents();
        if (pageContents[page.id]) {
            pageContents[newPage.id] = pageContents[page.id];
            localStorage.setItem('pageContents', JSON.stringify(pageContents));
        }
    }
}

/**
 * 初始化搜索功能
 */
function initSearchFunction() {
    const searchInput = document.getElementById('search-input');
    if (!searchInput) return;
    
    searchInput.addEventListener('input', function() {
        const query = this.value.toLowerCase().trim();
        const pagesData = DataService.getPagesData();
        
        if (!query) {
            // 如果搜索框为空，显示所有页面
            renderPageTree();
            return;
        }
        
        // 搜索页面
        const searchPages = (pages, query) => {
            return pages.filter(page => {
                // 检查标题是否匹配
                const titleMatch = page.title.toLowerCase().includes(query);
                
                // 递归检查子页面
                let childrenMatch = false;
                if (page.children && page.children.length > 0) {
                    page.children = searchPages(page.children, query);
                    childrenMatch = page.children.length > 0;
                }
                
                return titleMatch || childrenMatch;
            });
        };
        
        // 创建一个页面数据副本进行搜索
        const searchResults = { pages: searchPages([...pagesData.pages], query) };
        
        // 确保所有父目录都展开
        const expandParents = (pages, id) => {
            for (let page of pages) {
                if (page.type === 'directory' && page.children) {
                    if (page.children.some(child => child.id === id || (child.type === 'directory' && expandParents(child.children || [], id)))) {
                        page.expanded = true;
                        return true;
                    }
                }
            }
            return false;
        };
        
        // 展开所有包含匹配项的目录
        searchResults.pages.forEach(page => {
            if (page.type === 'directory') {
                page.expanded = true;
            }
        });
        
        // 临时替换页面数据并渲染
        // 使用DOM操作直接渲染搜索结果
        const pagesTree = document.getElementById('pages-tree');
        if (pagesTree) {
            pagesTree.innerHTML = '';
            
            if (searchResults.pages.length === 0) {
                pagesTree.innerHTML = `
                    <div style="padding: 20px; color: #999; text-align: center;">
                        <p>未找到匹配的页面</p>
                    </div>
                `;
                return;
            }
            
            searchResults.pages.forEach(page => {
                const pageElement = createPageElement(page);
                pagesTree.appendChild(pageElement);
            });
        }
    });
}

/**
 * 附加页面点击事件
 */
function attachPageClickEvents() {
    // 使用事件代理处理点击事件
    const pagesTree = document.getElementById('pages-tree');
    if (pagesTree) {
        pagesTree.addEventListener('click', (e) => {
            let target = e.target;
            
            // 如果点击的是折叠/展开按钮
            if (target.classList.contains('toggle-btn')) {
                const pageRow = target.closest('.page-row');
                if (pageRow) {
                    const pageId = pageRow.getAttribute('data-id');
                    const page = DataService.findPageById(pageId);
                    if (page && page.type === 'directory') {
                        toggleDirectory(page);
                    }
                }
                return;
            }
        });
    }
}

// 保持兼容性的函数
function saveContent() {
    DataService.forceSaveAllData();
}

function forceSaveAllData() {
    DataService.forceSaveAllData();
}

// 确保这些函数在全局可用
window.savePageContent = savePageContent;
window.saveContent = saveContent;
window.forceSaveAllData = forceSaveAllData; 